package libsvmRoot;

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.StringTokenizer;
import java.util.Vector;

public class svm_toy extends Applet {

    static final String DEFAULT_PARAM = "-t 2 -c 100";
    int XLEN;
    int YLEN;

    // off-screen buffer

    Image buffer;
    Graphics buffer_gc;

    // pre-allocated colors

    final static Color colors[] =
            {
                    new Color(0, 0, 0),
                    new Color(0, 120, 120),
                    new Color(120, 120, 0),
                    new Color(120, 0, 120),
                    new Color(0, 200, 200),
                    new Color(200, 200, 0),
                    new Color(200, 0, 200)
            };

    class point {
        point(double x, double y, byte value) {
            this.x = x;
            this.y = y;
            this.value = value;
        }

        double x, y;
        byte value;
    }

    Vector<point> point_list = new Vector<point>();
    byte current_value = 1;

    public void init() {
        setSize(getSize());

        final Button button_change = new Button("Change");
        Button button_run = new Button("Run");
        Button button_clear = new Button("Clear");
        Button button_save = new Button("Save");
        Button button_load = new Button("Load");
        final TextField input_line = new TextField(DEFAULT_PARAM);

        BorderLayout layout = new BorderLayout();
        this.setLayout(layout);

        Panel p = new Panel();
        GridBagLayout gridbag = new GridBagLayout();
        p.setLayout(gridbag);

        GridBagConstraints c = new GridBagConstraints();
        c.fill = GridBagConstraints.HORIZONTAL;
        c.weightx = 1;
        c.gridwidth = 1;
        gridbag.setConstraints(button_change, c);
        gridbag.setConstraints(button_run, c);
        gridbag.setConstraints(button_clear, c);
        gridbag.setConstraints(button_save, c);
        gridbag.setConstraints(button_load, c);
        c.weightx = 5;
        c.gridwidth = 5;
        gridbag.setConstraints(input_line, c);

        button_change.setBackground(colors[current_value]);

        p.add(button_change);
        p.add(button_run);
        p.add(button_clear);
        p.add(button_save);
        p.add(button_load);
        p.add(input_line);
        this.add(p, BorderLayout.SOUTH);

        button_change.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_change_clicked();
                button_change.setBackground(colors[current_value]);
            }
        });

        button_run.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_run_clicked(input_line.getText());
            }
        });

        button_clear.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_clear_clicked();
            }
        });

        button_save.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_save_clicked(input_line.getText());
            }
        });

        button_load.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_load_clicked();
            }
        });

        input_line.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                button_run_clicked(input_line.getText());
            }
        });

        this.enableEvents(AWTEvent.MOUSE_EVENT_MASK);
    }

    void draw_point(point p) {
        Color c = colors[p.value + 3];

        Graphics window_gc = getGraphics();
        buffer_gc.setColor(c);
        buffer_gc.fillRect((int) (p.x * XLEN), (int) (p.y * YLEN), 4, 4);
        window_gc.setColor(c);
        window_gc.fillRect((int) (p.x * XLEN), (int) (p.y * YLEN), 4, 4);
    }

    void clear_all() {
        point_list.removeAllElements();
        if (buffer != null) {
            buffer_gc.setColor(colors[0]);
            buffer_gc.fillRect(0, 0, XLEN, YLEN);
        }
        repaint();
    }

    void draw_all_points() {
        int n = point_list.size();
        for (int i = 0; i < n; i++)
            draw_point(point_list.elementAt(i));
    }

    void button_change_clicked() {
        ++current_value;
        if (current_value > 3) current_value = 1;
    }

    private static double atof(String s) {
        return Double.valueOf(s).doubleValue();
    }

    private static int atoi(String s) {
        return Integer.parseInt(s);
    }

    void button_run_clicked(String args) {
        // guard
        if (point_list.isEmpty()) return;

        libsvmRoot.libsvm.svm_parameter param = new libsvmRoot.libsvm.svm_parameter();

        // default values
        param.svm_type = libsvmRoot.libsvm.svm_parameter.C_SVC;
        param.kernel_type = libsvmRoot.libsvm.svm_parameter.RBF;
        param.degree = 3;
        param.gamma = 0;
        param.coef0 = 0;
        param.nu = 0.5;
        param.cache_size = 40;
        param.C = 1;
        param.eps = 1e-3;
        param.p = 0.1;
        param.shrinking = 1;
        param.probability = 0;
        param.nr_weight = 0;
        param.weight_label = new int[0];
        param.weight = new double[0];

        // parse options
        StringTokenizer st = new StringTokenizer(args);
        String[] argv = new String[st.countTokens()];
        for (int i = 0; i < argv.length; i++)
            argv[i] = st.nextToken();

        for (int i = 0; i < argv.length; i++) {
            if (argv[i].charAt(0) != '-') break;
            if (++i >= argv.length) {
                System.err.print("unknown option\n");
                break;
            }
            switch (argv[i - 1].charAt(1)) {
                case 's':
                    param.svm_type = atoi(argv[i]);
                    break;
                case 't':
                    param.kernel_type = atoi(argv[i]);
                    break;
                case 'd':
                    param.degree = atoi(argv[i]);
                    break;
                case 'g':
                    param.gamma = atof(argv[i]);
                    break;
                case 'r':
                    param.coef0 = atof(argv[i]);
                    break;
                case 'n':
                    param.nu = atof(argv[i]);
                    break;
                case 'm':
                    param.cache_size = atof(argv[i]);
                    break;
                case 'c':
                    param.C = atof(argv[i]);
                    break;
                case 'e':
                    param.eps = atof(argv[i]);
                    break;
                case 'p':
                    param.p = atof(argv[i]);
                    break;
                case 'h':
                    param.shrinking = atoi(argv[i]);
                    break;
                case 'b':
                    param.probability = atoi(argv[i]);
                    break;
                case 'w':
                    ++param.nr_weight;
                {
                    int[] old = param.weight_label;
                    param.weight_label = new int[param.nr_weight];
                    System.arraycopy(old, 0, param.weight_label, 0, param.nr_weight - 1);
                }

                {
                    double[] old = param.weight;
                    param.weight = new double[param.nr_weight];
                    System.arraycopy(old, 0, param.weight, 0, param.nr_weight - 1);
                }

                param.weight_label[param.nr_weight - 1] = atoi(argv[i - 1].substring(2));
                param.weight[param.nr_weight - 1] = atof(argv[i]);
                break;
                default:
                    System.err.print("unknown option\n");
            }
        }

        // build problem
        libsvmRoot.libsvm.svm_problem prob = new libsvmRoot.libsvm.svm_problem();
        prob.l = point_list.size();
        prob.y = new double[prob.l];

        if (param.kernel_type == libsvmRoot.libsvm.svm_parameter.PRECOMPUTED) {
        } else if (param.svm_type == libsvmRoot.libsvm.svm_parameter.EPSILON_SVR ||
                param.svm_type == libsvmRoot.libsvm.svm_parameter.NU_SVR) {
            if (param.gamma == 0) param.gamma = 1;
            prob.x = new libsvmRoot.libsvm.svm_node[prob.l][1];
            for (int i = 0; i < prob.l; i++) {
                point p = point_list.elementAt(i);
                prob.x[i][0] = new libsvmRoot.libsvm.svm_node();
                prob.x[i][0].index = 1;
                prob.x[i][0].value = p.x;
                prob.y[i] = p.y;
            }

            // build model & classify
            libsvmRoot.libsvm.svm_model model = libsvmRoot.libsvm.svm.svm_train(prob, param);
            libsvmRoot.libsvm.svm_node[] x = new libsvmRoot.libsvm.svm_node[1];
            x[0] = new libsvmRoot.libsvm.svm_node();
            x[0].index = 1;
            int[] j = new int[XLEN];

            Graphics window_gc = getGraphics();
            for (int i = 0; i < XLEN; i++) {
                x[0].value = (double) i / XLEN;
                j[i] = (int) (YLEN * libsvmRoot.libsvm.svm.svm_predict(model, x));
            }

            buffer_gc.setColor(colors[0]);
            buffer_gc.drawLine(0, 0, 0, YLEN - 1);
            window_gc.setColor(colors[0]);
            window_gc.drawLine(0, 0, 0, YLEN - 1);

            int p = (int) (param.p * YLEN);
            for (int i = 1; i < XLEN; i++) {
                buffer_gc.setColor(colors[0]);
                buffer_gc.drawLine(i, 0, i, YLEN - 1);
                window_gc.setColor(colors[0]);
                window_gc.drawLine(i, 0, i, YLEN - 1);

                buffer_gc.setColor(colors[5]);
                window_gc.setColor(colors[5]);
                buffer_gc.drawLine(i - 1, j[i - 1], i, j[i]);
                window_gc.drawLine(i - 1, j[i - 1], i, j[i]);

                if (param.svm_type == libsvmRoot.libsvm.svm_parameter.EPSILON_SVR) {
                    buffer_gc.setColor(colors[2]);
                    window_gc.setColor(colors[2]);
                    buffer_gc.drawLine(i - 1, j[i - 1] + p, i, j[i] + p);
                    window_gc.drawLine(i - 1, j[i - 1] + p, i, j[i] + p);

                    buffer_gc.setColor(colors[2]);
                    window_gc.setColor(colors[2]);
                    buffer_gc.drawLine(i - 1, j[i - 1] - p, i, j[i] - p);
                    window_gc.drawLine(i - 1, j[i - 1] - p, i, j[i] - p);
                }
            }
        } else {
            if (param.gamma == 0) param.gamma = 0.5;
            prob.x = new libsvmRoot.libsvm.svm_node[prob.l][2];
            for (int i = 0; i < prob.l; i++) {
                point p = point_list.elementAt(i);
                prob.x[i][0] = new libsvmRoot.libsvm.svm_node();
                prob.x[i][0].index = 1;
                prob.x[i][0].value = p.x;
                prob.x[i][1] = new libsvmRoot.libsvm.svm_node();
                prob.x[i][1].index = 2;
                prob.x[i][1].value = p.y;
                prob.y[i] = p.value;
            }

            // build model & classify
            libsvmRoot.libsvm.svm_model model = libsvmRoot.libsvm.svm.svm_train(prob, param);
            libsvmRoot.libsvm.svm_node[] x = new libsvmRoot.libsvm.svm_node[2];
            x[0] = new libsvmRoot.libsvm.svm_node();
            x[1] = new libsvmRoot.libsvm.svm_node();
            x[0].index = 1;
            x[1].index = 2;

            Graphics window_gc = getGraphics();
            for (int i = 0; i < XLEN; i++)
                for (int j = 0; j < YLEN; j++) {
                    x[0].value = (double) i / XLEN;
                    x[1].value = (double) j / YLEN;
                    double d = libsvmRoot.libsvm.svm.svm_predict(model, x);
                    if (param.svm_type == libsvmRoot.libsvm.svm_parameter.ONE_CLASS && d < 0) d = 2;
                    buffer_gc.setColor(colors[(int) d]);
                    window_gc.setColor(colors[(int) d]);
                    buffer_gc.drawLine(i, j, i, j);
                    window_gc.drawLine(i, j, i, j);
                }
        }

        draw_all_points();
    }

    void button_clear_clicked() {
        clear_all();
    }

    void button_save_clicked(String args) {
        FileDialog dialog = new FileDialog(new Frame(), "Save", FileDialog.SAVE);
        dialog.setVisible(true);
        String filename = dialog.getDirectory() + dialog.getFile();
        if (filename == null) return;
        try {
            DataOutputStream fp = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(filename)));

            int svm_type = libsvmRoot.libsvm.svm_parameter.C_SVC;
            int svm_type_idx = args.indexOf("-s ");
            if (svm_type_idx != -1) {
                StringTokenizer svm_str_st = new StringTokenizer(args.substring(svm_type_idx + 2).trim());
                svm_type = atoi(svm_str_st.nextToken());
            }

            int n = point_list.size();
            if (svm_type == libsvmRoot.libsvm.svm_parameter.EPSILON_SVR || svm_type == libsvmRoot.libsvm.svm_parameter.NU_SVR) {
                for (int i = 0; i < n; i++) {
                    point p = point_list.elementAt(i);
                    fp.writeBytes(p.y + " 1:" + p.x + "\n");
                }
            } else {
                for (int i = 0; i < n; i++) {
                    point p = point_list.elementAt(i);
                    fp.writeBytes(p.value + " 1:" + p.x + " 2:" + p.y + "\n");
                }
            }
            fp.close();
        } catch (IOException e) {
            System.err.print(e);
        }
    }

    void button_load_clicked() {
        FileDialog dialog = new FileDialog(new Frame(), "Load", FileDialog.LOAD);
        dialog.setVisible(true);
        String filename = dialog.getDirectory() + dialog.getFile();
        if (filename == null) return;
        clear_all();
        try {
            BufferedReader fp = new BufferedReader(new FileReader(filename));
            String line;
            while ((line = fp.readLine()) != null) {
                StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
                if (st.countTokens() == 5) {
                    byte value = (byte) atoi(st.nextToken());
                    st.nextToken();
                    double x = atof(st.nextToken());
                    st.nextToken();
                    double y = atof(st.nextToken());
                    point_list.addElement(new point(x, y, value));
                } else if (st.countTokens() == 3) {
                    double y = atof(st.nextToken());
                    st.nextToken();
                    double x = atof(st.nextToken());
                    point_list.addElement(new point(x, y, current_value));
                } else
                    break;
            }
            fp.close();
        } catch (IOException e) {
            System.err.print(e);
        }
        draw_all_points();
    }

    protected void processMouseEvent(MouseEvent e) {
        if (e.getID() == MouseEvent.MOUSE_PRESSED) {
            if (e.getX() >= XLEN || e.getY() >= YLEN) return;
            point p = new point((double) e.getX() / XLEN,
                    (double) e.getY() / YLEN,
                    current_value);
            point_list.addElement(p);
            draw_point(p);
        }
    }

    public void paint(Graphics g) {
        // create buffer first time
        if (buffer == null) {
            buffer = this.createImage(XLEN, YLEN);
            buffer_gc = buffer.getGraphics();
            buffer_gc.setColor(colors[0]);
            buffer_gc.fillRect(0, 0, XLEN, YLEN);
        }
        g.drawImage(buffer, 0, 0, this);
    }

    public Dimension getPreferredSize() {
        return new Dimension(XLEN, YLEN + 50);
    }

    public void setSize(Dimension d) {
        setSize(d.width, d.height);
    }

    public void setSize(int w, int h) {
        super.setSize(w, h);
        XLEN = w;
        YLEN = h - 50;
        clear_all();
    }

    public static void main(String[] argv) {
        new AppletFrame("svm_toy", new svm_toy(), 500, 500 + 50);
    }
}

class AppletFrame extends Frame {
    AppletFrame(String title, Applet applet, int width, int height) {
        super(title);
        this.addWindowListener(new WindowAdapter() {
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        });
        applet.init();
        applet.setSize(width, height);
        applet.start();
        this.add(applet);
        this.pack();
        this.setVisible(true);
    }
}
